package com.liangtian.mdm.material.service.impl;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.liangtian.mdm.base.dao.JdbcDao;
import com.liangtian.mdm.material.dao.WlTjfxDao;
import com.liangtian.mdm.material.model.WlTjfx;
import com.liangtian.mdm.material.service.WlTjfxService;

@Service
public class WlTjfxServiceImpl implements WlTjfxService {

    @Autowired
    private WlTjfxDao wlTjfxDao;
    @Autowired
    private JdbcDao jdbcDao;

    @Override
    public List<WlTjfx.WlTjfxResult> getTjfxByCreateTime(List<String> allTimeList, WlTjfx cond) {
        //--比如查询2018-01-01到2018-03-31范围的数据，那么allTimeList的长度为3【即：2018-01/2018-02/2018-03】;
        //--查询该范围内数据库中真实的数据，若上述查询范围，但2月份没有申请任何数据，则返回2018-01  x个、2018-03 y个 ，size为2.
        List<WlTjfx.WlTjfxResult> resultListDb = wlTjfxDao.getTjfxByCreateTime(cond);
        //--realResultList为经过加工后的真正的数据集合，返回前台使用
        List<WlTjfx.WlTjfxResult> realResultList = new ArrayList<WlTjfx.WlTjfxResult>();

        //--先遍历allTimeList
        for (String time : allTimeList) {
            //--定义变量，判断当前time在resultListDb中是否有记录，若有该值为true，否则为false
            boolean flag = false;
            //--再遍历数据库中查询的结果集
            for (WlTjfx.WlTjfxResult result : resultListDb) {
                String timeStr = result.getTime_str();
                if (timeStr.equals(time)) {
                    realResultList.add(result);
                    flag = true;
                    break;
                }
            }

            //--当前time在resultListDb没有记录，则创建一个数量为0的记录，相当于创建2018-02 0个，用于前台正常展示。
            if (!flag) {
                WlTjfx.WlTjfxResult result = new WlTjfx.WlTjfxResult();
                result.setTime_str(time);
                result.setCount_str("0");
                realResultList.add(result);
            }
        }

        return realResultList;
    }

    @Override
    public List<WlTjfx.WlTjfxResult> getTjfxByDlCreateTime(List<String> allTimeList, WlTjfx cond) {
        //--比如查询2018-01-01到2018-03-31范围的数据，那么allTimeList的长度为3【即：2018-01/2018-02/2018-03】;
        //--查询该范围内数据库中真实的大类下创建数据，若上述查询范围，假设共计查询01、02、03三个大类。但2月份02、03没有数据，3月份03大类没有数据，则返回类似：
        //--01:		2018-01 x个、		2018-02 y个、		2018-03 z个
        //--02:		2018-01 x2个、	2018-03 z2个，
        //--03:		2018-01 x3个.
        //--size为6.
        List<WlTjfx.WlTjfxResult> resultListDb = wlTjfxDao.getTjfxByDlCreateTime(cond);
        //--realResultList为经过加工后的真正的数据集合，返回前台使用
        List<WlTjfx.WlTjfxResult> realResultList = new ArrayList<WlTjfx.WlTjfxResult>();
        //--获取当前查询的所有大类的集合,这里按照大类code+大类名称作为唯一标识
        List<String> dlList = new ArrayList<String>();
        for (WlTjfx.WlTjfxResult result : resultListDb) {
            String dlCode = result.getDl_code();
            String dlDesc = result.getDl_desc();
            if (!dlList.contains(dlCode + "@@" + dlDesc)) {
                dlList.add(dlCode + "@@" + dlDesc);
            }
        }
        //--根据allTimeList【即：2018-01/2018-02/2018-03】和dlList[01/02/03]，二重循环，整理出所有月份下所有大类的数量。
        //--若resultListDb中有，则取出来，若没有，则new一个初始值0.

        //--先遍历大类,再遍历allTimeList
        for (String dl : dlList) {
            for (String time : allTimeList) {
                //--定义变量，判断当前time当前dl在resultListDb中是否有记录，若有该值为true，否则为false
                boolean flag = false;

                for (WlTjfx.WlTjfxResult result : resultListDb) {
                    String dlCodeStr = result.getDl_code();
                    String dlDescStr = result.getDl_desc();
                    String dlInfoStr = dlCodeStr + "@@" + dlDescStr;

                    String timeStr = result.getTime_str();
                    if (timeStr.equals(time) && dlInfoStr.equals(dl)) {
                        realResultList.add(result);
                        flag = true;
                        break;
                    }
                }

                //--当前time当前dl在resultListDb没有记录，则创建一个数量为0的记录，相当于创建02 2018-02 0个，用于前台正常展示。
                if (!flag) {
                    WlTjfx.WlTjfxResult result = new WlTjfx.WlTjfxResult();
                    result.setTime_str(time);
                    result.setDl_code(dl.split("@@")[0]);
                    result.setDl_desc(dl.split("@@")[1]);
                    result.setCount_str("0");
                    realResultList.add(result);
                }
            }
        }

        return realResultList;
    }

    @Override
    public List<WlTjfx.WlTjfxResult> getTjfxByCUserCreateTime(List<String> allTimeList, WlTjfx cond) {
        //--比如查询2018-01-01到2018-03-31范围的数据，那么allTimeList的长度为3【即：2018-01/2018-02/2018-03】;
        //--查询该范围内数据库中真实的申请人创建数据，若上述查询范围，假设共计查询zhangsan、lisi、wangwu三个用户。
        //--但2月份lisi、wangwu没有数据，3月份wangwu没有数据，则返回类似：
        //--zhangan:		2018-01 x个、		2018-02 y个、		2018-03 z个
        //--lisi:			2018-01 x2个、	2018-03 z2个，
        //--wangwu:			2018-01 x3个.
        //--size为6.
        List<WlTjfx.WlTjfxResult> resultListDb = wlTjfxDao.getTjfxByCUserCreateTime(cond);
        //--受限于sql性能，不能再sql中使用wm_concat和listagg等行转列函数，向在新凤鸣这种一个人在一个月创建了1千多数据的项目上 ，大约要等待40多秒才能出结果。
        //--故这个过程分成两个步骤，第一步仅仅查询申请人、申请时间段、申请数量，第二步在第一步结果上for循环，再根据申请人、申请时间段查询有多少被驳回过的数据
        StringBuffer sb = new StringBuffer();
        int length = 0;
        for (WlTjfx.WlTjfxResult result : resultListDb) {
            length++;

            sb.append("select '" + result.getUser_id() + "' ||',,'|| '" + result.getTime_str() + "' ||',,'||count(distinct data_id)")
                    .append("  from wf_run_history h where h.busi_table='WL_WL' ")
                    .append("   and h.pass='0'")
                    .append("   and h.data_id in (")
                    .append(" select w.wl_dr_id from wl_wl w where w.creator_id='" + result.getUser_id() + "'");

            if ("month".equals(cond.getMode()))
                sb.append(" and to_char(w.create_time,'yyyy-mm') like '%" + result.getTime_str() + "%'");
            else if ("season".equals(cond.getMode()))
                sb.append(" and to_char(w.create_time,'yyyy-mm') like '%" + result.getTime_str() + "%'");
            else if ("year".equals(cond.getMode()))
                sb.append(" and to_char(w.create_time,'yyyy-mm') like '%" + result.getTime_str() + "%'");

            sb.append(")");

            if (length != resultListDb.size())
                sb.append(" union all ");
        }

        List<String> list = jdbcDao.executeSqlSelectId(sb.toString());
        //--获取当前查询的所有申请人的集合,这里按照用户账号+用户名称作为唯一标识
        List<String> userList = new ArrayList<String>();

        for (WlTjfx.WlTjfxResult result : resultListDb) {
            for (String str : list) {
                String[] strArr = str.split(",,");
                String userId = strArr[0];
                String timeStr = strArr[1];
                String countStr = strArr[2];
                if (result.getUser_id().equals(userId) && result.getTime_str().equals(timeStr)) {
                    result.setFail_str(countStr);
                    break;
                }
            }

            String count_str = result.getCount_str();
            String fail_str = result.getFail_str();
            //--特殊情况特殊处理
            String successPercent = null;
            if ("0".equals(count_str) && "0".equals(fail_str)) {
                //successPercent = "-";
            } else {
                float count_float = Float.parseFloat(count_str);
                float fail_float = Float.parseFloat(fail_str);
                float success_float = (count_float - fail_float)/count_float;
                successPercent = String.valueOf(success_float*100);
                if (successPercent.endsWith(".0"))
                    successPercent = successPercent.substring(0, successPercent.length() - 2);

                successPercent += "%";
            }
            result.setSuccess_percent(successPercent);

            String userAccount = result.getUser_account();
            String userName = result.getUser_name();
            if (!userList.contains(userAccount + "@@" + userName)) {
                userList.add(userAccount + "@@" + userName);
            }
        }

        //--realResultList为经过加工后的真正的数据集合，返回前台使用
        List<WlTjfx.WlTjfxResult> realResultList = new ArrayList<WlTjfx.WlTjfxResult>();
        //--根据allTimeList【即：2018-01/2018-02/2018-03】和userList[zhangsan/lisi/wangwu]，二重循环，整理出所有月份下所有大类的数量。
        //--若resultListDb中有，则取出来，若没有，则new一个初始值0.
        //--先遍历申请人,再遍历allTimeList
        for (String user : userList) {
            for (String time : allTimeList) {
                //--定义变量，判断当前time当前dl在resultListDb中是否有记录，若有该值为true，否则为false
                boolean flag = false;

                for (WlTjfx.WlTjfxResult result : resultListDb) {
                    String userAccountStr = result.getUser_account();
                    String userNameStr = result.getUser_name();
                    String userInfoStr = userAccountStr + "@@" + userNameStr;

                    String timeStr = result.getTime_str();
                    if (timeStr.equals(time) && userInfoStr.equals(user)) {
                        realResultList.add(result);
                        flag = true;
                        break;
                    }
                }

                //--当前time当前dl在resultListDb没有记录，则创建一个数量为0的记录，相当于创建02 2018-02 0个，用于前台正常展示。
                if (!flag) {
                    WlTjfx.WlTjfxResult result = new WlTjfx.WlTjfxResult();
                    result.setTime_str(time);
                    result.setUser_account(user.split("@@")[0]);
                    result.setUser_name(user.split("@@")[1]);
                    result.setCount_str("0");
                    result.setFail_str("0");
                    realResultList.add(result);
                }
            }
        }

        return realResultList;
    }

    @Override
    public List<WlTjfx.WlTjfxResult> getTjfxByAUserApproveTime(List<String> allTimeList, WlTjfx cond) {
        //--比如查询2018-01-01到2018-03-31范围的数据，那么allTimeList的长度为3【即：2018-01/2018-02/2018-03】;
        //--查询该范围内数据库中真实的审核人审核数据，若上述查询范围，假设共计查询zhangsan、lisi、wangwu三个用户。
        //--但2月份lisi、wangwu没有数据，3月份wangwu没有数据，则返回类似：
        //--zhangan:		2018-01 x个、		2018-02 y个、		2018-03 z个
        //--lisi:			2018-01 x2个、	2018-03 z2个，
        //--wangwu:			2018-01 x3个.
        //--size为6.
        List<WlTjfx.WlTjfxResult> resultListDb = wlTjfxDao.getTjfxByAUserApproveTime(cond);
        //--补0，不知道什么原因，使用了round、max等函数后，sql执行在plsql中是0.01这样的效果，但是mybatis执行完后就是.01的效果
        setZero(resultListDb);

        //--realResultList为经过加工后的真正的数据集合，返回前台使用
        List<WlTjfx.WlTjfxResult> realResultList = new ArrayList<WlTjfx.WlTjfxResult>();
        //--获取当前查询的所有审核人的集合,这里按照用户账号+用户名称作为唯一标识
        List<String> userList = new ArrayList<String>();
        for (WlTjfx.WlTjfxResult result : resultListDb) {
            String userAccount = result.getUser_account();
            String userName = result.getUser_name();
            if (!userList.contains(userAccount + "@@" + userName)) {
                userList.add(userAccount + "@@" + userName);
            }
        }
        //--根据allTimeList【即：2018-01/2018-02/2018-03】和userList[zhangsan/lisi/wangwu]，二重循环，整理出所有月份下所有大类的数量。
        //--若resultListDb中有，则取出来，若没有，则new一个初始值0.

        //--先遍历审核人,再遍历allTimeList
        for (String user : userList) {
            for (String time : allTimeList) {
                //--定义变量，判断当前time当前dl在resultListDb中是否有记录，若有该值为true，否则为false
                boolean flag = false;

                for (WlTjfx.WlTjfxResult result : resultListDb) {
                    String userAccountStr = result.getUser_account();
                    String userNameStr = result.getUser_name();
                    String userInfoStr = userAccountStr + "@@" + userNameStr;

                    String timeStr = result.getTime_str();
                    if (timeStr.equals(time) && userInfoStr.equals(user)) {
                        realResultList.add(result);
                        flag = true;
                        break;
                    }
                }

                //--当前time当前dl在resultListDb没有记录，则创建一个数量为0的记录，相当于创建02 2018-02 0个，用于前台正常展示。
                if (!flag) {
                    WlTjfx.WlTjfxResult result = new WlTjfx.WlTjfxResult();
                    result.setTime_str(time);
                    result.setUser_account(user.split("@@")[0]);
                    result.setUser_name(user.split("@@")[1]);
                    result.setCount_str("0");
                    result.setMaxday_str("0");
                    result.setAvgday_str("0");
                    realResultList.add(result);
                }
            }
        }

        return realResultList;
    }

    private void setZero(List<WlTjfx.WlTjfxResult> resultListDb) {
        for (WlTjfx.WlTjfxResult result : resultListDb) {
            String maxday_str = result.getMaxday_str();
            String avgday_str = result.getAvgday_str();

            if (maxday_str.startsWith("."))
                result.setMaxday_str("0" + maxday_str);
            if (avgday_str.startsWith("."))
                result.setAvgday_str("0" + avgday_str);
        }
    }

}
